﻿#include <iostream>
using namespace std;

//int globalVar = 1;//全局变量存在数据段（静态区）
//static int staticGlobalVar = 1;//全局静态变量存在数据段（静态区）
//void Test1()
//{
//	static int staticVar = 1;//局部静态变量存在数据段（静态区）
//	int localVar = 1;//局部变量存在栈
//	int num1[10] = { 1, 2, 3, 4 };//整型数组num1是存在Test()函数栈帧中是局部的，因此num1存在栈
//	char char2[] = "abcd";//字符数组char2是存在Test()函数栈帧中是局部的，因此char2存在栈
//	const char* pChar3 = "abcd";//pChar3是局部指针变量，存储在栈上，其指向的"abcd"字符串是常量字符串是存在代码段(常量区)
//	int* ptr1 = (int*)malloc(sizeof(int) * 4);//ptr1是局部指针变量，存储在栈上，其指向的空间是从堆上申请的空间
//	int* ptr2 = (int*)calloc(4, sizeof(int));//ptr2是局部指针变量，存储在栈上，其指向的空间是从堆上申请的空间
//	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);//ptr3是局部指针变量，存储在栈上，其指向的空间是从堆上申请的空间
//	free(ptr1);
//	free(ptr3);
//}
//
//class Stack
//{
//public:
//	Stack(int capacity = 4)
//		:_capacity(capacity)
//		, _top(0)
//	{
//		int* tmp = (int*)malloc(sizeof(int) * capacity);
//		if (tmp == NULL)
//		{
//			perror("malloc fail:");
//			exit(-1);
//		}
//	}
//	~Stack()
//	{
//		if (_nums)
//		{
//			free(_nums);
//			_capacity = _top = 0;
//		}
//	}
//
//private:
//	int* _nums;
//	int _top;
//	int _capacity;
//};
//
//void Test()
//{
//	int* p1 = (int*)malloc(sizeof(int));
//	free(p1);
//	// 1.malloc/calloc/realloc的区别是什么？
//	int* p2 = (int*)calloc(4, sizeof(int));
//	int* p3 = (int*)realloc(p2, sizeof(int) * 10);
//	// 这里需要free(p2)吗？
//	free(p3);
//}
//int main()
//{
//	/*int a = 10;
//	char str[] = "hello";
//
//	cout << sizeof(a) << endl;
//	cout << strlen(str) << endl;*/
//
//	Test();
//	return 0;
//}

//int main()
//{
//	// 动态申请一个int类型的空间
//	int* pa = new int;
//	// 动态申请一个int类型的空间并初始化为10
//	int* pb = new int(10);
//	// 动态申请10个int类型的空间
//	int* nums1 = new int[10];
//	// 动态申请10个int类型的空间,并用{1, 2, 3, 4}初始化，不完全初始化，剩下的默认初始化为0
//	int* nums2 = new int[10] {1, 2, 3, 4};
//
//	delete pa;
//	delete pb;
//	delete[] nums1;
//	delete[] nums2;
//
//	return 0;
//}

//int main()
//{
//	int* pa = new int;
//	int* pb = new int(10);
//
//	int* nums1 = new int[10];
//	int* nums2 = new int[10] {1, 2, 3, 4};
//
//	delete pa;
//	delete pb;
//	delete[] nums1;
//	delete[] nums2;
//
//	return 0;
//}
//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a = 0)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//private:
//	int _a;
//};


//int main() 
//{
//	//malloc 和 new 最大的区别是对于自定义类型除了会开空间以外，new 还会调用构造函数完成对对象的初始化
//	A* pa1 = new A;
//	A* pa2 = (A*)malloc(sizeof(A));
//
//	//free 和 delete 最大的区别是对于自定义类型除了会释放空间以外，还会调用析构函数来完成对对象中资源的清理
//	delete pa1;
//	free(pa2);
//
//	return 0;
//}
//void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
//{
//	// try to allocate size bytes
//	void* p;
//	while ((p = malloc(size)) == 0)
//	{ 
//		if (_callnewh(size) == 0)
//		{
//			// report no memory
//			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
//			static const std::bad_alloc nomem;
//			_RAISE(nomem);
//		}
//	return (p);
//}
//
//	void operator delete(void* pUserData)
//	{
//		_CrtMemBlockHeader* pHead;
//		RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
//		if (pUserData == NULL)
//			return;
//		_mlock(_HEAP_LOCK);  /* block other threads */
//		__TRY
//			       	/* get a pointer to memory block header */
//			pHead = pHdr(pUserData);
//		         	/* verify block type */
//		_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
//		_free_dbg(pUserData, pHead->nBlockUse);
//		__FINALLY
//			_munlock(_HEAP_LOCK);  /* release other threads */
//		__END_TRY_FINALLY
//			return;
//	}
//#define free(p) _free_dbg(p, _NORMAL_BLOCK)

//int main()
//{
//	A* pa = (A*)operator new(sizeof(A));
//	operator delete(pa);
//	return 0;
//}

//void func()
//{
//	int* pa = new int;
//	delete pa;
//
//	int* pb = new int[10];
//	delete[] pb;
//}
#include <windows.h>
//void func()
//{
//	while (1)
//	{
//		int* pa = (int*)malloc(sizeof(int) * 1024 * 1024 * 100);
//		Sleep(1000);
//		cout << pa << endl;
//	}
//}
//void func()
//{
//	while (1)
//	{
//		int* pa = new int[1024 * 1024 * 100];
//		Sleep(1000);
//		cout << pa << endl;
//	}
//}
//int main()
//{
//	try 
//	{
//		func();
//	}
//	catch (exception& e)
//	{
//		cout << e.what() << endl;
//	}
//	return 0;
//}
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};


// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)operator new(sizeof(A));
	new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}
//int main()
//{
//	A* pa = new A[10];
//	delete[] pa;
//	return 0;
//}
//int main()
//{
//	A* pa = new A;
//	delete pa;
//	return 0;
//}
